package com.yichi.util;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;

public class Utils {

    /**
     * 将 byte[] 转换为 ArrayList<Integer>，每两个字节转换为一个integer
     *
     * @param byteArray
     * @return
     */
    public static ArrayList<Integer> byteArray2IntegerList(byte[] byteArray) {
        ArrayList<Integer> resultList = new ArrayList<>();

        // 确保byte数组长度是偶数，否则最后一个字节会无法成对处理
        if (byteArray.length % 2 != 0) {
            throw new IllegalArgumentException("byte[] length should be even");
        }

        // 每两个字节转换为一个Integer
        for (int i = 0; i < byteArray.length; i += 2) {
            // 将两个字节合并成一个Integer，注意字节顺序
            int value = ((byteArray[i] & 0xFF) << 8) | (byteArray[i + 1] & 0xFF);
            resultList.add(value);
        }

        return resultList;
    }

    /**
     * 将 ArrayList<Integer> 转换为 ArrayList<Short>。
     *
     * @param integerList 要转换的 ArrayList<Integer>
     * @return 转换后的 ArrayList<Short>
     * @throws IllegalArgumentException 如果 Integer 值超出 Short 范围，抛出异常
     */
    public static ArrayList<Short> integerList2ShortList(ArrayList<Integer> integerList) {
        ArrayList<Short> shortList = new ArrayList<>();
        for (Integer num : integerList) {
            // 检查 Integer 是否在 Short 范围内
            if (num >= Short.MIN_VALUE && num <= Short.MAX_VALUE) {
                shortList.add(num.shortValue());  // 转换为 Short 并添加到列表
            } else {
                // 如果超出范围，抛出异常
                throw new IllegalArgumentException("Integer " + num + " 超出 Short 的范围。");
            }
        }
        return shortList;
    }

    /**
     * 将 short 转换为 byte[]，2 字节表示
     *
     * @param number short 数值
     * @return byte[] 数组
     */
    public static byte[] short2ByteArray(Short number) {
        byte[] byteArray = new byte[2];
        // 高字节
        byteArray[0] = (byte) (number >> 8); // 获取高字节 (16 位中的高 8 位)
        // 低字节
        byteArray[1] = (byte) (number.shortValue()); // 获取低字节 (16 位中的低 8 位)
        return byteArray;
    }

    /**
     * 将 ArrayList<Short> 转换为二进制数组（byte[]）。
     *
     * @param shortList 要转换的 ArrayList<Short>
     * @return 转换后的 byte[] 数组
     */
    public static byte[] shortList2ByteArray(ArrayList<Short> shortList) {
        // 创建一个足够大的 byte[] 数组，ArrayList<Short> 中每个 Short 占 2 个字节
        byte[] byteArray = new byte[shortList.size() * 2];

        // 遍历 ArrayList<Short>，将每个 Short 转换为 2 个字节
        int index = 0;
        for (Short s : shortList) {
            byteArray[index++] = (byte) (s >> 8); // 高字节
            byteArray[index++] = (byte) (s.shortValue());      // 低字节
        }

        return byteArray;
    }

    /**
     * 将 Short[] 转换为二进制数组（byte[]）。
     *
     * @param shorts 要转换的 Short[]
     * @return 转换后的 byte[] 数组
     */
    public static byte[] shortList2ByteArray(Short[] shorts) {
        // 创建一个足够大的 byte[] 数组，ArrayList<Short> 中每个 Short 占 2 个字节
        byte[] byteArray = new byte[shorts.length * 2];

        // 遍历 ArrayList<Short>，将每个 Short 转换为 2 个字节
        int index = 0;
        for (Short s : shorts) {
            byteArray[index++] = (byte) (s >> 8); // 高字节
            byteArray[index++] = (byte) (s.shortValue());      // 低字节
        }

        return byteArray;
    }

    /**
     * 将 ArrayList<Short> 转换为二进制字符串数组，每个 Short 转为 16 位二进制字符串。
     *
     * @param shortList 要转换的 ArrayList<Short>
     * @return 转换后的二进制字符串数组
     */
    public static String[] shortList2BinaryStringArray(ArrayList<Short> shortList) {
        String[] binaryStrings = new String[shortList.size()];

        // 遍历每个 Short，将其转换为 16 位的二进制字符串
        int index = 0;
        for (Short s : shortList) {
            // 将 Short 转换为 16 位二进制字符串
            binaryStrings[index++] = String.format("%16s", Integer.toBinaryString(s & 0xFFFF)).replace(' ', '0');
        }

        return binaryStrings;
    }

    /**
     * 将 byte[] 转换为二进制字符串数组，每个 byte 转为 8 位二进制字符串。
     *
     * @param byteArray 要转换的 byte[] 数组
     * @return 转换后的二进制字符串数组
     */
    public static String[] byteArray2BinaryStringArray(byte[] byteArray) {
        String[] binaryStrings = new String[byteArray.length];

        // 遍历每个 byte，将其转换为 8 位二进制字符串
        for (int i = 0; i < byteArray.length; i++) {
            // 将 byte 转换为 8 位二进制字符串
            binaryStrings[i] = String.format("%8s", Integer.toBinaryString(byteArray[i] & 0xFF)).replace(' ', '0');
        }

        return binaryStrings;
    }

    /**
     * 提取指定位置的字符并将其转换为整数。
     *
     * @param str      输入的数字字符串
     * @param position 要提取的字符位置（从0开始）
     * @return 指定位置字符对应的整数值
     * @throws IndexOutOfBoundsException 如果索引超出范围
     * @throws NumberFormatException     如果指定位置的字符不是数字
     */
    public static int getDigitAtPosition(String str, int position) throws IndexOutOfBoundsException, NumberFormatException {
        // 检查字符串是否为空或者位置是否有效
        if (str == null || position < 0 || position >= str.length()) {
            throw new IndexOutOfBoundsException("指定位置无效");
        }

        // 提取字符
        char charAtPos = str.charAt(position);

        // 检查字符是否是数字
        if (Character.isDigit(charAtPos)) {
            return charAtPos - '0';  // 将字符转换为整数值
        } else {
            throw new NumberFormatException("指定位置的字符不是有效的数字");
        }
    }

    /**
     * 字符串反转
     *
     * @param s
     * @return
     */
    public static String reverseString(String s) {
        return new StringBuffer(s).reverse().toString();
    }

    /**
     * Integer转换为byte
     *
     * @param number
     * @return
     */
    public static byte integer2Byte(Integer number) {
        // 确保输入的数字在0到255之间（无符号字节的范围）
        if (number < 0 || number > 255) {
            throw new IllegalArgumentException("数字必须在0到255之间");
        }

        // 强制转换为byte（无符号范围通过int表示）
        return (byte) number.intValue();
    }

    // 将 byte 转换为 Integer
    public static Integer byte2Integer(byte b) {
        return b & 0xFF; // 无符号转换
    }

    // 将 ArrayList<Short> 转换为 Short[] 数组
    public static Short[] shortList2ShortArray(ArrayList<Short> list) {
        return list.toArray(new Short[0]);
    }

    /**
     * 字节数组转字符串，编码为ASC码
     * 这个字节为0会解析为\u0000
     *
     * @param bytes
     * @return
     */
    public static String byteArray2String(byte[] bytes) {
        String str = new String(bytes, StandardCharsets.US_ASCII);
        str = str.replace("\u0000", "");
        return str;
    }

    /**
     * 从给定的byte数组中提取指定长度的子数组
     *
     * @param source 原始byte数组
     * @param start  起始位置（从0开始）
     * @param length 提取的长度
     * @return 提取的子数组
     * @throws IllegalArgumentException 如果起始位置或长度超出范围
     */
    public static byte[] subByteArray(byte[] source, int start, int length) {
        if (source == null) {
            throw new IllegalArgumentException("源byte数组不能为空");
        }
        if (start < 0 || length < 0 || start + length > source.length) {
            throw new IllegalArgumentException("起始位置或长度超出范围");
        }

        byte[] result = new byte[length];
        System.arraycopy(source, start, result, 0, length);
        return result;
    }

    public static short[] byteArray2ShortArray(byte[] bytes) {
        if (bytes.length % 2 != 0) {
            throw new IllegalArgumentException("字节数组长度必须是2的倍数！");
        }

        short[] shorts = new short[bytes.length / 2];
        for (int i = 0; i < shorts.length; i++) {
            // 将两个字节合成一个short (大端模式)
            shorts[i] = (short) ((bytes[i * 2] << 8) | (bytes[i * 2 + 1] & 0xFF));
        }
        return shorts;
    }

    /**
     * 1个字节转int。无符号
     *
     * @return
     */
    public static int oneByteToInt(byte b) {
        int unsignedInt = b & 0xFF; // 无符号转换
        return unsignedInt;
    }

    /**
     * 将2字节的byte数组转换为int类型
     *
     * @param bytes 字节数组，长度必须为2
     * @return 转换后的int值
     * @throws IllegalArgumentException 如果字节数组长度不是2
     */
    public static int twoBytesToInt(byte[] bytes) {
        if (bytes == null || bytes.length != 2) {
            throw new IllegalArgumentException("Byte array must have exactly 2 bytes");
        }
        byte highByte = bytes[0];
        byte lowByte = bytes[1];
        // 将byte转换为无符号int（& 0xFF避免符号扩展）
        int high = highByte & 0xFF;
        int low = lowByte & 0xFF;
        // 组合成无符号整数
        return (high << 8) | low;
    }

    /**
     * 4个字节转int
     *
     * @param bytes
     * @return
     */
    public static int fourBytesToInt(byte[] bytes) {
        if (bytes == null || bytes.length != 4) {
            throw new IllegalArgumentException("Byte array must be non-null and have exactly 4 bytes.");
        }
        return ((bytes[0] & 0xFF) << 24) |
                ((bytes[1] & 0xFF) << 16) |
                ((bytes[2] & 0xFF) << 8) |
                (bytes[3] & 0xFF);
    }

    /**
     * int转1个字节。无符号
     *
     * @return
     */
    public static byte intToOneByte(int num) {
        byte unsignedByte = (byte) (num & 0xFF); // 截断高位，保留低8位
        return unsignedByte;
    }

    /**
     * 把名字变为*号
     *
     * @param str
     * @return
     */
    public static String maskString(String str) {
        if (str == null || str.length() <= 1) {
            return str;
        }
        StringBuilder masked = new StringBuilder(str.length());
        masked.append(str.charAt(0)); // 添加第一位
        for (int i = 1; i < str.length(); i++) {
            masked.append('*'); // 剩下的变成 *
        }
        return masked.toString();
    }

    /**
     * 获取行驶里程
     * @return
     */
    public static float getMileage(Integer soc, Integer soh) {
        float lc = (float) (45 * (soc / 100.0) * (soh / 100.0));
        lc = Math.round(lc * 10) / 10;
        return lc;
    }

    // 获取应用的 versionName
    public static String getAppVersionName(Context context) {
        try {
            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
            return packageInfo.versionName;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

}
